import { Provide } from '@midwayjs/core';
import { BaseService } from '@cool-midway/core';
import { InjectEntityModel } from '@midwayjs/typeorm';
import { Repository } from 'typeorm';
import { OrderOrderEntity } from '../entity/order';
import { OrderZhongtianEntity } from '../entity/zhongtian';
import { OrderZhongtianGoodsEntity } from '../entity/zhongtianGoods';
import axios from 'axios';
import * as moment from 'moment';
import * as md5 from 'md5';
import { OrderGoodsEntity } from '../entity/goods';

/**
 * 订单模块-店铺信息Service
 */
@Provide()
export class OrderTongkangService extends BaseService {
  @InjectEntityModel(OrderZhongtianEntity)
  orderZhongtianEntity: Repository<OrderZhongtianEntity>;

  @InjectEntityModel(OrderZhongtianGoodsEntity)
  orderZhongtianGoodsEntity: Repository<OrderZhongtianGoodsEntity>;

  @InjectEntityModel(OrderOrderEntity)
  orderOrderEntity: Repository<OrderOrderEntity>;

  @InjectEntityModel(OrderGoodsEntity)
  orderGoodsEntity: Repository<OrderGoodsEntity>;

  private lock = Promise.resolve();

  // 中天平台配置，需要根据实际情况修改
  private tongkangConfig = {
    url: 'https://www.gzsmd.com.cn/prod-api/open/ord-by-pair',
    appid: 'tk01',
    appsecrect: 'c9c74594071231b7e921e0de14ea91ed',
    userid: 'tk01',
  };

  async getUrl(url = '') {
    const timestamp = Math.floor(Date.now() / 1000);
    const sign = md5(timestamp + this.tongkangConfig.appsecrect).toLowerCase();
    return `${url}?sign=${sign}&timestamp=${timestamp}&appid=${this.tongkangConfig.appid}`;
  }

  async getProcessParamsV3(params) {
    if (params.orderId) {
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.orderId,
        },
      });
      // console.log(order);
      if (
        Number(order.totalAmount) === 2980 ||
        Number(order.totalAmount) === 3980 ||
        Number(order.totalAmount) === 1990 || // 医疗版单眼
        Number(order.totalAmount) === 1300 || // 视光版升级医疗版
        Number(order.totalAmount) === 650 // 视光版升级医疗版 单眼
      ) {
        return {
          // 加工方式
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+ETC',
              'label': '易洁膜'
            }
          ]
        }
      }
      if (Number(order.totalAmount) === 2680 || Number(order.totalAmount) === 1340) {
        return {
          // 加工方式
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+ETC',
              'label': '加硬膜'
            }
          ]
        }
      }
    }
    return {
      // 加工方式
      'c_process_type': [
        {
          'value': 'M',
          'label': '全框'
        },
        {
          'value': '&',
          'label': '半框'
        },
        {
          'value': 'ME',
          'label': '特殊材质'
        }
      ],
      // 镀膜
      'c_coating_type': [
        {
          'value': 'CR+BRC',
          'label': '防蓝光膜'
        },
        {
          'value': 'CR+HDC',
          'label': '高清膜'
        }
      ]
    }
  }

  async getProcessParamsV2(params) {
    if (params.orderId) {
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.orderId,
        },
      });
      // console.log(order);
      if (Number(order.totalAmount) === 2980 || Number(order.totalAmount) === 3980) {
        return {
          // 加工方式
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+ETC',
              'label': '易洁膜'
            }
          ]
        }
      }
      if (Number(order.totalAmount) === 2680) {
        return {
          // 加工方式
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+ETC',
              'label': '加硬膜'
            }
          ]
        }
      }
    }
    return {
      // 加工方式
      'c_process_type': [
        {
          'value': 'M',
          'label': '全框'
        },
        {
          'value': '&',
          'label': '半框'
        },
        {
          'value': 'ME',
          'label': '特殊材质'
        }
      ],
      // 镀膜
      'c_coating_type': [
        {
          'value': 'CR+BRC',
          'label': '防蓝光膜'
        },
        {
          'value': 'CR+HDC',
          'label': '高清膜'
        }
      ]
    }
  }

  async getProcessParamsList() {
    return {
      // 加工方式
      '2980': {
        data: {
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+ETC',
              'label': '易洁膜'
            },
            {
              'value': 'CR+BRC',
              'label': '防蓝光膜'
            },
            {
              'value': 'CR+HDC',
              'label': '高清膜'
            }
          ]
        }
      },
      '3980': {
        data: {
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+ETC',
              'label': '易洁膜'
            },
            {
              'value': 'CR+BRC',
              'label': '防蓝光膜'
            },
            {
              'value': 'CR+HDC',
              'label': '高清膜'
            }
          ]
        }
      },
      '2680': {
        data: {
          // 加工方式
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+ETC',
              'label': '加硬膜'
            }
          ]
        }
      },
      '3280': {
        data: {
          // 加工方式
          'c_process_type': [
            {
              'value': 'M',
              'label': '全框'
            },
            {
              'value': '&',
              'label': '半框'
            },
            {
              'value': 'ME',
              'label': '特殊材质'
            }
          ],
          // 镀膜
          'c_coating_type': [
            {
              'value': 'CR+BRC',
              'label': '防蓝光膜'
            },
            {
              'value': 'CR+HDC',
              'label': '高清膜'
            }
          ]
        }
      },
    }
  }

  // 获取加工参数
  async getProcessParams() {
    return {
      // 加工方式
      'c_process_type': [
        {
          'value': 'M',
          'label': '全框'
        },
        {
          'value': '&',
          'label': '半框'
        },
        {
          'value': 'ME',
          'label': '特殊材质'
        }
      ],
      // 镀膜
      'c_coating_type': [
        {
          'value': 'CR+HDC',
          'label': '高清膜'
        },
        {
          'value': 'CR+ETC',
          'label': '易洁膜'
        },
        {
          'value': 'CR+BRC',
          'label': '防蓝光膜'
        }
      ]
    }
  }

  // 获取商品列表
  async getGoodsListV3(params) {
    if (params.orderId) {
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.orderId,
        },
      });
      if (Number(order.totalAmount) === 2680 || Number(order.totalAmount) === 1340) {
        return [{
          'ADD1': '0',
          'ADD2': '0',
          'CYL1': '-600',
          'CYL2': '0',
          'SPH1': '-1200',
          'SPH2': '400',
          'lens_code': 'OSK159HKOOFETC',
          'lens_desc': '小虎点点双面复合离焦(定制)镜片标准版',
          'show_add': true,
        }];
      }
    }
    return [{
      'ADD1': '50',
      'ADD2': '400',
      'CYL1': '-600',
      'CYL2': '0',
      'SPH1': '-1200',
      'SPH2': '400',
      'lens_code': 'OTK159HKOOFETC',
      'lens_desc': '小虎点点双面复合离焦(定制)镜片医疗版',
      'show_add': true,
    }, {
      'ADD1': '0',
      'ADD2': '0',
      'CYL1': '-600',
      'CYL2': '0',
      'SPH1': '-1200',
      'SPH2': '400',
      'lens_code': 'OTK159HKONFETC',
      'lens_desc': '小虎点点双面复合离焦(定制)镜片N医疗版',
      'show_add': false,
    }];
  }

  // 获取商品列表
  async getGoodsListV2(params) {
    if (params.orderId) {
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.orderId,
        },
      });
      if (Number(order.totalAmount) === 2680) {
        return [{
          'ADD1': '0',
          'ADD2': '0',
          'CYL1': '-600',
          'CYL2': '0',
          'SPH1': '-1200',
          'SPH2': '400',
          'lens_code': 'OSK159HKOOFETC',
          'lens_desc': '小虎点点双面复合离焦(定制)镜片标准版',
          'show_add': true,
        }];
      }
    }
    return [{
      'ADD1': '50',
      'ADD2': '400',
      'CYL1': '-600',
      'CYL2': '0',
      'SPH1': '-1200',
      'SPH2': '400',
      'lens_code': 'OTK159HKOOFETC',
      'lens_desc': '小虎点点双面复合离焦(定制)镜片医疗版',
      'show_add': true,
    }, {
      'ADD1': '0',
      'ADD2': '0',
      'CYL1': '-600',
      'CYL2': '0',
      'SPH1': '-1200',
      'SPH2': '400',
      'lens_code': 'OTK159HKONFETC',
      'lens_desc': '小虎点点双面复合离焦(定制)镜片N医疗版',
      'show_add': false,
    }];
  }

  // 获取商品列表
  async getGoodsList() {

    return [{
      'ADD1': '50',
      'ADD2': '400',
      'CYL1': '-600',
      'CYL2': '0',
      'SPH1': '-1200',
      'SPH2': '400',
      'lens_code': 'OTK159HKOOFETC',
      'lens_desc': '小虎点点双面复合离焦(定制)镜片医疗版',
      'show_add': true,
      'money': 3980,
    }, {
      'ADD1': '0',
      'ADD2': '0',
      'CYL1': '-600',
      'CYL2': '0',
      'SPH1': '-1200',
      'SPH2': '400',
      'lens_code': 'OTK159HKONFETC',
      'lens_desc': '小虎点点双面复合离焦(定制)镜片N医疗版',
      'show_add': false,
      'money': 2980,
    }, {
      'ADD1': '0',
      'ADD2': '0',
      'CYL1': '-600',
      'CYL2': '0',
      'SPH1': '-1200',
      'SPH2': '400',
      'lens_code': 'OSK159HKOOFETC',
      'lens_desc': '小虎点点双面复合离焦(定制)镜片标准版',
      'show_add': true,
      'money': 2680,
    }];

    try {
      const url = 'https://www.gzsmd.com.cn/prod-api/open/prodlist';

      // 构建完整的请求URL，包含sign、timestamp和appid参数
      const requestUrl = await this.getUrl(url);

      console.log('请求URL:', requestUrl);

      // 发送请求获取新token
      const response = await axios.get(requestUrl, {
        headers: {
          'Content-Type': 'application/json',
        },
      });
      console.log('响应数据:', response.data);
      if (response.data.code === 20000) {
        // 遍历将文字中包含“内购”的数据剔除掉
        response.data.data = response.data.data.filter((item: any) => {
          return item.lens_desc.indexOf('内购') === -1;
        });
        return response.data.data;
      } else {
        throw new Error('获取商品列表失败');
      }
    } catch (error) {
      throw new Error(error.message);
    }
  }

  // 门店新增订单
  async addOrder(params) {
    await this.lock;
    try {
      if (!params.eyeglassImg) {
        throw new Error('请上传电脑验光单，用户才可以享受183天上涨50度免费更换的服务');
      }
      // 根据订单ID获取订单
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.order_id,
        },
      });
      if (!order) {
        throw new Error('订单不存在');
      }
      // 如果订单已经下单过则提示已下单
      if (order.orderProgress != 0 && order.orderProgress != 1) {
        throw new Error('该订单已下单，无法修改');
      }
      // 根据商品ID获取商品的配镜限制
      const goods = await this.orderGoodsEntity.findOne({
        where: {
          id: Number(order.GoodIds),
          isDeleted: false,
        },
      });
      if (!goods) {
        throw new Error('商品不存在');
      }

      /**
       * 可选的球镜: [可选的柱镜]
       */
      if (params.lensQuantity == 0) {
        if (!goods.lensData.ballLimit[params.c_rball] || !goods.lensData.ballLimit[params.c_lball]) {
          throw new Error('球镜参数不在可选项范围内');
        } else {
          if (goods.lensData.ballLimit[params.c_rball].indexOf(params.c_rpole.toString()) === -1 || goods.lensData.ballLimit[params.c_lball].indexOf(params.c_lpole.toString()) === -1) {
            throw new Error('柱镜参数不在可选项范围内');
          }
        }
      } else if (params.lensQuantity == 1) {
        if (!goods.lensData.ballLimit[params.c_lball]) {
          throw new Error('球镜参数不在可选项范围内');
        } else {
          if (goods.lensData.ballLimit[params.c_lball].indexOf(params.c_lpole.toString()) === -1) {
            throw new Error('柱镜参数不在可选项范围内');
          }
        }
      } else if (params.lensQuantity == 2) {
        if (!goods.lensData.ballLimit[params.c_rball]) {
          throw new Error('球镜参数不在可选项范围内');
        } else {
          if (goods.lensData.ballLimit[params.c_rball].indexOf(params.c_rpole.toString()) === -1) {
            throw new Error('柱镜参数不在可选项范围内');
          }
        }
      } else {
        throw new Error('镜片数量参数不在可选项范围内');
      }
      // 将获取到的编号保存到订单中
      // order.tongkangOrderNo = order.orderNo;
      // order.tongkangOrderTime = new Date();
      order.optometricsData = JSON.stringify(params);
      console.log('order.optometricsData', order.optometricsData, params);
      order.shopOrderTime = new Date();
      order.orderProgress = 1; // 门店下单完成
      order.eyeglassImg = params.eyeglassImg;
      order.eyeglassImg = params.eyeglassImg;
      await this.orderOrderEntity.save(order);
      this.lock = Promise.resolve();
    } catch (error) {
      console.error('新增订单失败:', error);
      throw error;
    }
  }

  async addTongkangOrder(params) {
    await this.lock;
    try {
      // 根据订单ID获取订单
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.order_id
        }
      });
      if (!order) {
        throw new Error('订单不存在');
      }
      // 检查订单状态
      if (order.orderProgress !== 1) {
        throw new Error('订单状态错误');
      }
      const url = 'https://www.gzsmd.com.cn/prod-api/open/ord-by-pair';
      const requestUrl = await this.getUrl(url);
      let reqeustData = order.tongkangOrderRequestData;

      // 处理请求数据，将odate设置为当前时间
      try {
        // 尝试解析请求数据为对象
        let requestDataObj = typeof reqeustData === 'string' ? JSON.parse(reqeustData.replace(/\\/g, '')) : reqeustData;
        // 设置odate为当前时间
        requestDataObj.odate = moment().format('YYYY-MM-DD HH:mm:ss');
        reqeustData = requestDataObj;
      } catch (parseError) {
        console.error('解析请求数据失败:', parseError);
      }
      order.tongkangOrderRequestData = JSON.stringify(reqeustData);
      await this.orderOrderEntity.save(order);
      const order2 = await this.orderOrderEntity.findOne({
        where: {
          id: params.order_id
        }
      });
      const reqeustData2 = order2.tongkangOrderRequestData;
      console.log('reqeustData', requestUrl, reqeustData, reqeustData2);
      // 发送POST请求
      const response = await axios.post(requestUrl, reqeustData2);
      if (response.data.code === 20000) {
        console.log('response.data', response.data);
        order.tongkangOrderNo = response.data.data;
        order.tongkangOrderTime = new Date();
        order.orderProgress = 2; // 瞳康下单完成
        await this.orderOrderEntity.save(order);
        this.lock = Promise.resolve();
        return response.data;
      } else {
        throw new Error(response.data.message);
      }
    } catch (error) {
      console.error('新增订单失败:', error);
      throw error;
    }
  }

  async editTongkangOrder(params) {
    try {
      // 根据订单ID获取订单
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.order_id,
        },
      });
      if (!order) {
        throw new Error('订单不存在');
      }
      // 检查订单状态
      if (order.orderProgress !== 2) {
        throw new Error('订单状态错误');
      }

      const reqeustData = {
        'id': order.orderNo,
        'shopid': '',
        // 'odate': moment(order.createTime).format('YYYY-MM-DD HH:mm:ss'),
        // 当前时间
        'odate': moment().format('YYYY-MM-DD HH:mm:ss'),

        del_address: params.receiveAddress, // 寄送地址
        contacts: params.contactName, // 联系人
        tel: params.contactPhone, // 手机号
        remark: params.remark || '', // 备注

        lenscoder: params.c_goods_r,
        lensdescr: params.c_goods_r_desc,
        diar: params.c_diar,
        sphr: params.c_rball,
        cylr: params.c_rpole,
        addr: params.c_radd,
        axisr: params.c_rline,
        qtyr: params.c_rnum,

        lenscodel: params.c_goods_l,
        lensdescl: params.c_goods_l_desc,
        dial: params.c_dial,
        sphl: params.c_lball,
        cyll: params.c_lpole,
        addl: params.c_ladd,
        axisl: params.c_lline,
        qtyl: params.c_lnum,

        // 瞳距
        pd: params.pd_r + '/' + params.pd_l,
        // 瞳高
        ph: params.ph_r + '/' + params.ph_l,

        chebian: (params.c_process_type && params.c_process_type != '&') || '', // 如果是选开坑的则传开坑
        juse: params.c_coating_type || '',
        kaikeng:
          params.c_process_type && params.c_process_type == '&' ? '&' : '',
      };

      const url =
        'https://www.gzsmd.com.cn/prod-api/open/ord-by-pair/' + order.orderNo;
      const requestUrl = await this.getUrl(url);
      console.log('reqeustData', requestUrl, reqeustData);
      // 发送PUT请求获取新token
      const response = await axios.put(requestUrl, reqeustData);
      if (response.data.code === 20000) {
        console.log('response.data', response.data);
        order.tongkangOrderNo = response.data.data;
        order.tongkangOrderTime = new Date();
        await this.orderOrderEntity.save(order);
        return response.data;
      } else {
        throw new Error(response.data.message);
      }
    } catch (error) {
      console.error('修改订单失败:', error);
      throw error;
    }
  }

  // 取消订单
  async cancelOrder(params) {
    try {
      // 根据订单ID获取订单
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.order_id,
        },
      });
      if (!order) {
        throw new Error('订单不存在');
      }
      // 检查订单状态
      if (order.orderProgress !== 2) {
        throw new Error('订单状态错误');
      }
      const url =
        'https://www.gzsmd.com.cn/prod-api/open/ord-by-pair/' +
        order.orderNo +
        '/cancel';
      const requestUrl = await this.getUrl(url);
      console.log('reqeustData', requestUrl);
      // 发送PATCH请求取消订单
      const response = await axios.patch(requestUrl);
      console.log('response', url, response.data);
      if (response.data.code === 20000) {
        order.tongkangOrderTime = new Date();
        order.orderProgress = 1; // 瞳康订单已取消
        await this.orderOrderEntity.save(order);
        return response.data;
      } else {
        throw new Error(response.data.message);
      }
    } catch (error) {
      console.error('取消订单失败:', error);
      throw error;
    }
  }

  // 查询订单信息
  async viewOrder(params) {
    try {
      // 根据订单ID获取订单
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.order_id,
        },
      });
      if (!order) {
        throw new Error('订单不存在');
      }

      return order;
    } catch (error) {
      console.error('查询订单失败:', error);
      throw error;
    }
  }

  // 查询订单
  async getOrderLogs(params) {
    if (!params.order_id) {
      throw new Error('订单ID不能为空');
    }
    const order = await this.orderOrderEntity.findOne({
      where: {
        id: params.order_id,
      },
    });
    if (!order) {
      throw new Error('订单不存在');
    }

    const url =
      'https://www.gzsmd.com.cn/prod-api/open/ord-by-pair/' +
      order.orderNo +
      '/logs';
    // const url = 'https://www.gzsmd.com.cn/prod-api/open/ord-by-pair/20250905151434239598306020/logs';

    const requestUrl = await this.getUrl(url);
    const response = await axios.get(requestUrl);
    console.log(response.data);
    if (response.data.code === 20000) {
      return response.data;
    } else {
      throw new Error(response.data.message);
    }
  }

  // 检查订单
  async checkOrder(params) {
    console.log('params', params);
    try {
      // 根据订单ID获取订单
      const order = await this.orderOrderEntity.findOne({
        where: {
          id: params.order_id,
        },
      });
      if (!order) {
        throw new Error('订单不存在');
      }
      // if (params.eyeglassImg && params.eyeglassImg != order.eyeglassImg) {
      //   order.eyeglassImg = params.eyeglassImg;
      //   await this.orderOrderEntity.save(order);
      // }
      // if (!order.eyeglassImg || order.eyeglassImg == '') {
      //   throw new Error('请上传电脑验光单，用户才可以享受183天上涨50度免费更换的服务');
      // }
      // 度数验证逻辑
      const { c_goods_l, c_lball, c_rball, c_lpole, c_rpole, lensQuantity } = params;
      const lball = c_lball;
      const rball = c_rball;
      const lpole = c_lpole;
      const rpole = c_rpole;

      // if (c_goods_l == 'OSK159HKOOFETC') {
      //   // 视光版
      //   if (lensQuantity == 1 || lensQuantity == 0) {
      //     if (lensQuantity == 1) {
      //       params.c_rball = 0
      //       params.c_rpole = 0
      //       params.c_goods_r = 0
      //       params.c_radd = 0
      //       params.c_rline = 0
      //       params.c_goods_r_desc = 0
      //       params.c_diar = 0
      //     }
      //     if (lensQuantity == 1) {
      //       params.c_rball = 0
      //       params.c_rpole = 0
      //       params.c_goods_r = 0
      //       params.c_radd = 0
      //       params.c_rline = 0
      //       params.c_goods_r_desc = 0
      //       params.c_diar = 0
      //     }
      //     if (lball >= -400 && lball <= 100 && lpole <= 0 && lpole >= -200) {
      //       // 符合条件，继续执行
      //     } else {
      //       throw new Error('此产品不支持当前度数无法生产，如有需要请联系代理商');
      //     }
      //   }
      //   // 视光版
      //   if (lensQuantity == 2 || lensQuantity == 0) {
      //     if (lensQuantity == 2) {
      //       params.c_lball = 0
      //       params.c_lpole = 0
      //       params.c_goods_l = 0
      //       params.c_ladd = 0
      //       params.c_lline = 0
      //       params.c_goods_l_desc = 0
      //       params.c_dial = 0
      //     }
      //     if (lensQuantity == 2) {
      //       params.c_lball = 0
      //       params.c_lpole = 0
      //       params.c_goods_l = 0
      //       params.c_ladd = 0
      //       params.c_lline = 0
      //       params.c_goods_l_desc = 0
      //       params.c_dial = 0
      //     }
      //     if (rball >= -400 && rball <= 100 && rpole <= 0 && rpole >= -200) {
      //       // 符合条件，继续执行
      //     } else {
      //       throw new Error('此产品不支持当前度数无法生产，如有需要请联系代理商');
      //     }
      //   }
      // } else if (c_goods_l == 'OTK159HKOOFETC' || c_goods_l == 'OTK159HKONFETC') {
      //   if (lensQuantity == 1 || lensQuantity == 0) {
      //     if (lensQuantity == 1) {
      //       if (lensQuantity == 1) {
      //       params.c_rball = 0
      //         params.c_rpole = 0
      //         params.c_goods_r = 0
      //         params.c_radd = 0
      //         params.c_rline = 0
      //         params.c_goods_r_desc = 0
      //         params.c_diar = 0
      //     }
      //     }
      //     console.log("rline", params.c_rline)
      //     if (lball > 0 && lball <= 100 && lpole <= 0 && lpole >= -200) {
      //     } else if (lball <= 0 && lball >= -625 && lpole <= 0 && lpole >= -400) {
      //       // } else if (lball < -625 && lpole + lball >= -1000) {
      //     } else if (lball < -625 && lball >= -650 && lpole <= 0 && lpole >= -375) {
      //       // -650 到 -626 的区间判断
      //     } else if (lball < -650 && lball >= -675 && lpole <= 0 && lpole >= -350) {
      //       // -675 到 -651 的区间判断
      //     } else if (lball < -675 && lball >= -700 && lpole <= 0 && lpole >= -325) {
      //       // -700 到 -676 的区间判断
      //     } else if (lball < -700 && lball >= -725 && lpole <= 0 && lpole >= -300) {
      //       // -725 到 -701 的区间判断
      //     } else if (lball < -725 && lball >= -750 && lpole <= 0 && lpole >= -275) {
      //       // -750 到 -726 的区间判断
      //     } else if (lball < -750 && lball >= -775 && lpole <= 0 && lpole >= -250) {
      //       // -775 到 -751 的区间判断
      //     } else if (lball < -775 && lball >= -800 && lpole <= 0 && lpole >= -225) {
      //       // -800 到 -776 的区间判断
      //     } else if (lball < -800 && lball >= -825 && lpole <= 0 && lpole >= -200) {
      //       // -825 到 -801 的区间判断
      //     } else if (lball < -825 && lball >= -850 && lpole <= 0 && lpole >= -175) {
      //       // -850 到 -826 的区间判断
      //     } else if (lball < -850 && lball >= -875 && lpole <= 0 && lpole >= -150) {
      //       // -875 到 -851 的区间判断
      //     } else if (lball < -875 && lball >= -900 && lpole <= 0 && lpole >= -125) {
      //       // -900 到 -876 的区间判断
      //     } else if (lball < -900 && lball >= -925 && lpole <= 0 && lpole >= -100) {
      //       // -925 到 -901 的区间判断
      //     } else if (lball < -925 && lball >= -950 && lpole <= 0 && lpole >= -75) {
      //       // -950 到 -926 的区间判断
      //     } else if (lball < -950 && lball >= -975 && lpole <= 0 && lpole >= -50) {
      //       // -975 到 -951 的区间判断
      //     } else if (lball < -975 && lball > -1000 && lpole <= 0 && lpole >= -25) {
      //       // -999 到 -976 的区间判断
      //     } else if (lball == -1000 && lpole == 0) {
      //     } else {
      //       throw new Error('此产品不支持当前度数无法生产，如有需要请联系代理商');
      //     }
      //   }

      //   if (lensQuantity == 2 || lensQuantity == 0) {
      //     if (lensQuantity == 2) {
      //       if (lensQuantity == 2) {
      //       params.c_lball = 0
      //         params.c_lpole = 0
      //         params.c_goods_l = 0
      //         params.c_ladd = 0
      //         params.c_lline = 0
      //         params.c_goods_l_desc = 0
      //         params.c_dial = 0
      //     }
      //     }
      //     if (rball > 0 && rball <= 100 && rpole <= 0 && rpole >= -200) {
      //     } else if (rball <= 0 && rball >= -625 && rpole <= 0 && rpole >= -400) {
      //       // } else if (rball < -625 && rpole + rball >= -1000) {
      //     } else if (rball < -625 && rball >= -650 && rpole <= 0 && rpole >= -375) {
      //       // -650 到 -626 的区间判断
      //     } else if (rball < -650 && rball >= -675 && rpole <= 0 && rpole >= -350) {
      //       // -675 到 -651 的区间判断
      //     } else if (rball < -675 && rball >= -700 && rpole <= 0 && rpole >= -325) {
      //       // -700 到 -676 的区间判断
      //     } else if (rball < -700 && rball >= -725 && rpole <= 0 && rpole >= -300) {
      //       // -725 到 -701 的区间判断
      //     } else if (rball < -725 && rball >= -750 && rpole <= 0 && rpole >= -275) {
      //       // -750 到 -726 的区间判断
      //     } else if (rball < -750 && rball >= -775 && rpole <= 0 && rpole >= -250) {
      //       // -775 到 -751 的区间判断
      //     } else if (rball < -775 && rball >= -800 && rpole <= 0 && rpole >= -225) {
      //       // -800 到 -776 的区间判断
      //     } else if (rball < -800 && rball >= -825 && rpole <= 0 && rpole >= -200) {
      //       // -825 到 -801 的区间判断
      //     } else if (rball < -825 && rball >= -850 && rpole <= 0 && rpole >= -175) {
      //       // -850 到 -826 的区间判断
      //     } else if (rball < -850 && rball >= -875 && rpole <= 0 && rpole >= -150) {
      //       // -875 到 -851 的区间判断
      //     } else if (rball < -875 && rball >= -900 && rpole <= 0 && rpole >= -125) {
      //       // -900 到 -876 的区间判断
      //     } else if (rball < -900 && rball >= -925 && rpole <= 0 && rpole >= -100) {
      //       // -925 到 -901 的区间判断
      //     } else if (rball < -925 && rball >= -950 && rpole <= 0 && rpole >= -75) {
      //       // -950 到 -926 的区间判断
      //     } else if (rball < -950 && rball >= -975 && rpole <= 0 && rpole >= -50) {
      //       // -975 到 -951 的区间判断
      //     } else if (rball < -975 && rball > -1000 && rpole <= 0 && rpole >= -25) {
      //       // -999 到 -976 的区间判断
      //     } else if (rball == -1000 && rpole == 0) {
      //     } else {
      //       throw new Error('此产品不支持当前度数无法生产，如有需要请联系代理商');
      //     }
      //   }
      // }

      // c_rline和c_lline只能是5的倍数
      // if (params.c_rline % 5 !== 0 || params.c_lline % 5 !== 0) {
      //     throw new Error('c_rline和c_lline只能是5的倍数');
      // }

      // 查看是否有小数点，有则不是整数
      if (String(params.c_diar).indexOf('.') !== -1 || String(params.c_dial).indexOf('.') !== -1) {
        throw new Error('直径必须为整数');
      }

      if (String(params.c_rball).indexOf('.') !== -1 || String(params.c_lball).indexOf('.') !== -1) {
        throw new Error('球镜必须为整数');
      }

      if (String(params.c_rpole).indexOf('.') !== -1 || String(params.c_lpole).indexOf('.') !== -1) {
        throw new Error('柱镜必须为整数');
      }

      if (String(params.c_radd).indexOf('.') !== -1 || String(params.c_ladd).indexOf('.') !== -1) {
        throw new Error('后表面离焦量必须为整数');
      }

      if (String(params.c_rline).indexOf('.') !== -1 || String(params.c_lline).indexOf('.') !== -1) {
        throw new Error('散光轴向必须为整数');
      }

      // 判断直径是否为整数
      if (!Number.isInteger(Number(params.c_diar)) || !Number.isInteger(Number(params.c_dial))) {
        throw new Error('直径必须为整数');
      }

      // 判断球镜是否为整数
      if (!Number.isInteger(Number(params.c_rball)) || !Number.isInteger(Number(params.c_lball))) {
        throw new Error('球镜必须为整数');
      }

      // 判断柱镜是否为整数
      if (!Number.isInteger(Number(params.c_rpole)) || !Number.isInteger(Number(params.c_lpole))) {
        throw new Error('柱镜必须为整数');
      }

      // 判断后表面离焦量是否为整数
      if (!Number.isInteger(Number(params.c_radd)) || !Number.isInteger(Number(params.c_ladd))) {
        throw new Error('后表面离焦量必须为整数');
      }

      // 判断散光轴向是否为整数
      if (!Number.isInteger(Number(params.c_rline)) || !Number.isInteger(Number(params.c_lline))) {
        throw new Error('散光轴向必须为整数');
      }

      if (params.lensQuantity != 0 && params.lensQuantity != 1 && params.lensQuantity != 2) {
        throw new Error('镜片数量错误');
      }

      const url = 'https://www.gzsmd.com.cn/prod-api/open/verify-by-pair';
      const requestUrl = await this.getUrl(url);
      const reqeustData = {
        'id': order.orderNo,
        'shopid': '',
        // 'odate': moment(order.createTime).format('YYYY-MM-DD HH:mm:ss'),
        // 当前时间
        'odate': moment().format('YYYY-MM-DD HH:mm:ss'),

        del_address: params.receiveAddress, // 寄送地址
        contacts: params.contactName, // 联系人
        tel: params.contactPhone, // 手机号
        remark: params.remark || '', // 备注

        lenscoder: params.c_goods_r,
        lensdescr: params.c_goods_r_desc,
        diar: params.c_diar,
        sphr: params.c_rball,
        cylr: params.c_rpole,
        addr: params.c_radd,
        axisr: params.c_rline,
        qtyr: params.c_rnum,

        lenscodel: params.c_goods_l,
        lensdescl: params.c_goods_l_desc,
        dial: params.c_dial,
        sphl: params.c_lball,
        cyll: params.c_lpole,
        addl: params.c_ladd,
        axisl: params.c_lline,
        qtyl: params.c_lnum,

        // 瞳距
        pd: params.pd_r + '/' + params.pd_l,
        // 瞳高
        ph: params.ph_r + '/' + params.ph_l,

        chebian: (params.c_process_type && params.c_process_type != '&') || '', // 如果是选开坑的则传开坑
        juse: params.c_coating_type || '',
        kaikeng:
          params.c_process_type && params.c_process_type == '&' ? '&' : '',
      };
      // console.log('reqeustData', requestUrl, reqeustData, params);
      console.log('reqeustData', reqeustData);

      // 发送POST请求获取新token
      const response = await axios.post(requestUrl, reqeustData);
      // console.log('检查订单失败', response);
      if (response.data.code === 20000) {
        order.tongkangOrderRequestData = JSON.stringify(reqeustData);
        await this.orderOrderEntity.save(order);
        return response.data;
      } else {
        throw new Error(response.data.message);
      }
    } catch (error) {
      console.error('检查订单失败:', error);
      throw error;
    }
  }
}
